\n
\n");
if let Some(url) = &self.clone_url {
let _ = writeln!(html, "{}
\n", escape(&self.name)); if let Some(desc) = &self.description { let _ = writeln!(html, "{}
", escape(desc)); } html.push_str("git clone {}", escape(url));
}
html.push_str("\ \ \ {short}\
\n", author = escape(&author), summary = escape(&summary), short = commit.id().shorten_or_id(), date = escape(&date_of(&commit)), ) } pub struct RefTip { pub kind: RefKind, pub name: String, pub commit_id: gix::ObjectId, pub static_mode: Option");
let line_count = code.len();
for (i, line) in code.into_iter().enumerate() {
let number = i + 1;
let _ = write!(
source,
"{number}{line}"
);
if number < line_count {
source.push_str("\n");
}
source.push_str("");
}
source.push_str("");
if is_markdown(name) {
let rendered = markdown(hl, &text);
let _ = writeln!(
body,
"\
\
\
\
\
{rendered} \
",
);
} else {
let _ = writeln!(body, "{source}");
}
}
let title = format!("{} - {} @ {}", joined, ctx.name, ctx.label);
let description = format!("{joined} in {} at {}.", ctx.name, ctx.label);
write_file(
&ctx.out.join(&rel),
page(&ctx.instance_name, &title, &description, Some((&ctx.label, ctx.tip_id)), &body),
)
}
fn reuse_blob(
previous: &Path,
previous_versions: &BTreeMap{source}
\
\n
\n");
html
}
/// `/refs`: branch and tag tables with tip summaries and dates.
pub fn render_refs_page(site: &Site, tips: &[RefTip], out: &Path) -> Result<()> {
let head = head_tip(site.repo, tips);
let mut body = format!(
"{}languages", ); for stat in stats { let percentage = stat.bytes as f64 * 100.0 / total as f64; let _ = write!( html, "", escape(stat.name), percentage, stat.color, ); } html.push_str("
\n- \n");
for stat in stats {
let percentage = stat.bytes as f64 * 100.0 / total as f64;
let _ = writeln!(
html,
"
- {} {:.1}% ", stat.id, stat.color, escape(stat.name), percentage, ); } html.push_str("
{heading}
\n| {name} | {summary} |
files
\n"); body.push_str(&self.listing(path, entries)); } body.push_str(&self.readme_section(entries)); let title = if path.is_empty() { format!("{} @ {}", self.site.name, self.label) } else { format!("{}/ - {} @ {}", path.join("/"), self.site.name, self.label) }; let description = if path.is_empty() { format!("Source tree for {} at {}.", self.site.name, self.label) } else { format!( "{} in {} at {}.", path.join("/"), self.site.name, self.label, ) }; write_file( &self.out.join(&rel), page(&self.site.instance_name, &title, &description, Some((&self.label, self.tip_id)), &body), ) } /// Root-page layout: file listing beside a recent-commits log. fn overview(&self, entries: &[Entry]) -> String { format!( "files
\n{}recent commits
\n- \n");
let mut shown = Vec::with_capacity(SHOWN);
let mut parents = Vec::new();
let mut truncated = false;
let Ok(walk) = self.site.repo.rev_walk([self.tip_id]).all() else {
return String::new();
};
for (n, info) in walk.flatten().enumerate() {
if n == SHOWN {
truncated = true;
break;
}
let Ok(commit) = self
.site
.repo
.find_object(info.id)
.map_err(anyhow::Error::from)
.and_then(|o| Ok(o.try_into_commit()?))
else {
continue;
};
shown.push(info.id);
parents.extend(commit.parent_ids().map(|id| id.detach()));
let change_id = commit
.decode()
.ok()
.and_then(|c| c.extra_headers().find("change-id").map(|v| v.to_string()));
let cid = change_id
.as_deref()
.map(|c| {
format!(
"{} ",
info.id,
escape(&c[..c.len().min(8)]),
)
})
.unwrap_or_default();
let summary = commit.message().map(|m| m.summary().to_string()).unwrap_or_default();
let author = commit.author().map(|a| a.name.to_string()).unwrap_or_default();
let _ = writeln!(
s,
"
- {cid}{sha} {author}{summary} ", full = info.id, sha = commit.id().shorten_or_id(), author = escape(&author), date = escape(&date_of(&commit)), summary = escape(&summary), ); } s.push_str("
| {name}/ | |
| {name}{sigil} | {size} |
| {name} @ {oid:.8} |
` dropdown listing all refs. Baked at build time, so
/// pages of refs untouched since a ref was added/deleted list it stale;
/// the always-rebuilt index and refs pages stay fresh.
fn switcher(&self) -> String {
let mut s = format!(
"",
self.site.base_url,
);
s
}
/// Breadcrumb nav: site name / path components, all but the last linked.
fn crumbs(&self, path: &[String], last_is_file: bool) -> String {
let mut nav = format!(
"\n");
nav
}
}
/// Author date; the in-browser client also renders author time, so dates
/// match site-wide.
fn date_of(commit: &gix::Commit<'_>) -> String {
author_time(commit)
.map(|t| t.format_or_unix(gix::date::time::format::SHORT))
.unwrap_or_default()
}
fn author_time(commit: &gix::Commit<'_>) -> Option {
commit.author().ok()?.time().ok()
}
fn find_readme(repo: &gix::Repository, entries: &[Entry]) -> Option<(String, Vec)> {
["readme.md", "readme", "readme.txt"].iter().find_map(|want| {
entries.iter().find_map(|(name, kind, oid)| {
(matches!(kind, EntryKind::File) && name.to_lowercase() == *want)
.then(|| Some((name.clone(), repo.find_object(*oid).ok()?.data.to_vec())))
.flatten()
})
})
}
fn is_markdown(name: &str) -> bool {
let name = name.to_lowercase();
name.ends_with(".md") || name.ends_with(".markdown")
}
fn readme_html(hl: &mut Highlighter, name: &str, data: &[u8]) -> String {
let text = String::from_utf8_lossy(data);
if is_markdown(name) {
markdown(hl, &text)
} else {
format!("{code}\n").into()))
}
Event::Html(s) => Some(Event::Text(s)),
Event::InlineHtml(s) => Some(Event::Text(s)),
ev => Some(ev),
});
let mut out = String::new();
html::push_html(&mut out, events);
out
}
fn human_size(bytes: u64) -> String {
const UNITS: &[&str] = &["KiB", "MiB", "GiB", "TiB"];
if bytes < 1024 {
return format!("{bytes} B");
}
let mut size = bytes as f64;
let mut unit = "";
for u in UNITS {
size /= 1024.0;
unit = u;
if size < 1024.0 {
break;
}
}
format!("{size:.1} {unit}")
}
#[cfg(test)]
mod tests {
use std::collections::BTreeMap;
use std::fs;
use std::os::unix::fs::symlink;
use anyhow::Result;
use crate::highlight::Highlighter;
use crate::testutil::{TempDir, commit, git, grammar_cache, init_repo};
use super::{
BlobVersion, EntryKind, RefKind, collapse_lone_dirs, collect_entries, encode_path,
find_readme, head_tip, human_size, list_refs, markdown, reuse_blob,
};
#[test]
fn encodes_url_paths() {
assert_eq!(encode_path("a b/c?d#\u{e9}").to_string(), "a%20b/c%3Fd%23%C3%A9");
}
#[test]
fn human_sizes_switch_units_at_1024() {
assert_eq!(human_size(0), "0 B");
assert_eq!(human_size(1023), "1023 B");
assert_eq!(human_size(1024), "1.0 KiB");
assert_eq!(human_size(1536), "1.5 KiB");
assert_eq!(human_size(1 << 20), "1.0 MiB");
assert_eq!(human_size(1 << 40), "1.0 TiB");
assert_eq!(human_size(1 << 50), "1024.0 TiB");
}
#[test]
fn tree_entries_list_directories_first_then_by_name() -> Result<()> {
let root = TempDir::new("entries");
let repo_path = root.join("repo");
init_repo(&repo_path)?;
for dir in ["zeta", "alpha"] {
fs::create_dir(repo_path.join(dir))?;
fs::write(repo_path.join(dir).join("keep"), "")?;
}
fs::write(repo_path.join("beta"), "")?;
fs::write(repo_path.join("aardvark"), "")?;
symlink("beta", repo_path.join("gamma"))?;
commit(&repo_path, "first")?;
let repo = gix::open(&repo_path)?;
let entries = collect_entries(&repo.head_commit()?.tree()?)?;
let names: Vec<_> = entries.iter().map(|(name, ..)| name.as_str()).collect();
assert_eq!(names, ["alpha", "zeta", "aardvark", "beta", "gamma"]);
assert!(matches!(entries[1].1, EntryKind::Dir));
assert!(matches!(entries[2].1, EntryKind::File));
assert!(matches!(entries[4].1, EntryKind::Link));
Ok(())
}
#[test]
fn lone_directory_chains_collapse_into_one_name() -> Result<()> {
let root = TempDir::new("collapse");
let repo_path = root.join("repo");
init_repo(&repo_path)?;
fs::create_dir_all(repo_path.join("a/b/c"))?;
fs::write(repo_path.join("a/b/c/keep"), "")?;
fs::create_dir_all(repo_path.join("x/y"))?;
fs::write(repo_path.join("x/y/keep"), "")?;
fs::write(repo_path.join("x/stop"), "")?;
commit(&repo_path, "first")?;
let repo = gix::open(&repo_path)?;
let entries = collect_entries(&repo.head_commit()?.tree()?)?;
let collapsed: Vec<_> = entries
.iter()
.map(|(name, _, oid)| collapse_lone_dirs(&repo, name, *oid))
.collect();
assert_eq!(collapsed, ["a/b/c", "x"]);
Ok(())
}
#[test]
fn readme_lookup_prefers_markdown_ignores_case_and_skips_directories() -> Result<()> {
let root = TempDir::new("readme");
let repo_path = root.join("repo");
init_repo(&repo_path)?;
fs::write(repo_path.join("readme.txt"), "txt")?;
fs::write(repo_path.join("README"), "bare")?;
fs::write(repo_path.join("ReadMe.MD"), "md")?;
commit(&repo_path, "first")?;
let repo = gix::open(&repo_path)?;
let entries = collect_entries(&repo.head_commit()?.tree()?)?;
let (name, data) = find_readme(&repo, &entries).unwrap();
assert_eq!((name.as_str(), data.as_slice()), ("ReadMe.MD", b"md".as_slice()));
fs::remove_file(repo_path.join("ReadMe.MD"))?;
fs::create_dir(repo_path.join("readme.md"))?;
fs::write(repo_path.join("readme.md/keep"), "")?;
commit(&repo_path, "second")?;
let entries = collect_entries(&repo.head_commit()?.tree()?)?;
let (name, data) = find_readme(&repo, &entries).unwrap();
assert_eq!((name.as_str(), data.as_slice()), ("README", b"bare".as_slice()));
Ok(())
}
#[test]
fn refs_skip_non_commit_tags_and_let_branches_shadow_tags() -> Result<()> {
let root = TempDir::new("refs");
let repo_path = root.join("repo");
init_repo(&repo_path)?;
fs::write(repo_path.join("file"), "")?;
commit(&repo_path, "first")?;
git(&repo_path, &["tag", "main"])?;
git(&repo_path, &["tag", "v1"])?;
let blob = git(&repo_path, &["rev-parse", "HEAD:file"])?;
git(&repo_path, &["tag", "blobtag", &blob])?;
let repo = gix::open(&repo_path)?;
let mut tips: Vec<_> = list_refs(&repo)?
.into_iter()
.map(|tip| (tip.kind, tip.name))
.collect();
tips.sort_by(|a, b| a.1.cmp(&b.1));
assert_eq!(tips, [(RefKind::Branch, "main".into()), (RefKind::Tag, "v1".into())]);
Ok(())
}
#[test]
fn head_tip_follows_head_and_falls_back_to_any_branch() -> Result<()> {
let root = TempDir::new("head");
let repo_path = root.join("repo");
init_repo(&repo_path)?;
fs::write(repo_path.join("file"), "")?;
commit(&repo_path, "first")?;
git(&repo_path, &["branch", "aaa"])?;
let repo = gix::open(&repo_path)?;
let tips = list_refs(&repo)?;
assert_eq!(head_tip(&repo, &tips).unwrap().name, "main");
git(&repo_path, &["checkout", "-q", "--detach"])?;
let repo = gix::open(&repo_path)?;
assert_eq!(head_tip(&repo, &tips).unwrap().kind, RefKind::Branch);
git(&repo_path, &["symbolic-ref", "HEAD", "refs/heads/unborn"])?;
let repo = gix::open(&repo_path)?;
assert_eq!(head_tip(&repo, &tips).unwrap().kind, RefKind::Branch);
Ok(())
}
#[test]
fn markdown_never_passes_through_raw_html() {
let mut hl = Highlighter::new(grammar_cache());
let html = markdown(
&mut hl,
"\n\n\
text bold\n\n\
```no-such-lang\n
\n```\n",
);
assert!(html.contains("<script>"), "{html}");
for forbidden in [" Result<()> {
let root = TempDir::new("blob-reuse");
let previous = root.join("previous");
let out = root.join("out");
fs::create_dir_all(previous.join("blob/src"))?;
fs::write(previous.join("blob/src/main.rs"), "highlighted")?;
let old = BlobVersion {
oid: "abc123".into(),
mode: 0o100644,
touched: "first".into(),
};
let previous_versions = BTreeMap::from([("src/main.rs".into(), old.clone())]);
let changed = BlobVersion {
touched: "second".into(),
..old.clone()
};
let changed_versions = BTreeMap::from([("src/main.rs".into(), changed)]);
let versions = BTreeMap::from([("src/main.rs".into(), old)]);
assert!(!reuse_blob(
&previous,
&previous_versions,
&changed_versions,
"src/main.rs",
&out,
));
assert!(reuse_blob(
&previous,
&previous_versions,
&versions,
"src/main.rs",
&out,
));
assert_eq!(
fs::read_to_string(out.join("blob/src/main.rs"))?,
"highlighted",
);
Ok(())
}
}
{}
{}\n", escape(&text))
}
}
fn markdown(hl: &mut Highlighter, src: &str) -> String {
use pulldown_cmark::{html, CodeBlockKind, Event, Options, Parser, Tag, TagEnd};
let opts = Options::ENABLE_TABLES
| Options::ENABLE_STRIKETHROUGH
| Options::ENABLE_FOOTNOTES
| Options::ENABLE_TASKLISTS;
// Buffer fenced code blocks so they get the same arborium treatment as
// blob pages; escape raw HTML rather than pulling in a sanitizer.
let mut fence: Option<(Option<&'static str>, String)> = None;
let events = Parser::new_ext(src, opts).filter_map(|ev| match ev {
Event::Start(Tag::CodeBlock(CodeBlockKind::Fenced(info))) => {
// only the first word names the language: ```rust,ignore
let lang = info
.split(|c: char| c == ',' || c.is_whitespace())
.next()
.and_then(crate::grammar_manifest::canonical);
fence = Some((lang, String::new()));
None
}
Event::Text(t) if fence.is_some() => {
fence.as_mut().expect("checked in guard").1.push_str(&t);
None
}
Event::End(TagEnd::CodeBlock) if fence.is_some() => {
let (lang, code) = fence.take().expect("checked in guard");
let class = lang.map(|l| format!(" class=\"language-{l}\"")).unwrap_or_default();
let code = lang
.and_then(|lang| hl.highlight(lang, &code).ok())
.unwrap_or_else(|| escape(&code).to_string());
Some(Event::Html(format!("